using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Collections;
using System.Data;
using System.ComponentModel;
using System.Data.OracleClient;
using WPFExcelReport.Helpers;
using WPFExcelReport.Controls;
namespace WPFExcelReport
{
   public partial class VICC_WBERROR
    {
      #region======ColumnSchema==========
       /*
                public string MANDANT { get { if (dwMaster == null) return ""; return dwMaster["MANDANT"].ToString(); } set { if (dwMaster == null) return; dwMaster["MANDANT"] = value; OnPropertyChanged("MANDANT", value); } } //lENGth 2
                public string LO { get { if (dwMaster == null) return ""; return dwMaster["LO"].ToString(); } set { if (dwMaster == null) return; dwMaster["LO"] = value; OnPropertyChanged("LO", value); } } //lENGth 2
                public string LB { get { if (dwMaster == null) return ""; return dwMaster["LB"].ToString(); } set { if (dwMaster == null) return; dwMaster["LB"] = value; OnPropertyChanged("LB", value); } } //lENGth 2
                public double MDATE { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["MDATE"].ToString()); } set { if (dwMaster == null) return; dwMaster["MDATE"] = value; OnPropertyChanged("MDATE", value); } } //lENGth 0
                public string WAKZ { get { if (dwMaster == null) return ""; return dwMaster["WAKZ"].ToString(); } set { if (dwMaster == null) return; dwMaster["WAKZ"] = value; OnPropertyChanged("WAKZ", value); } } //lENGth 1
                public string ART { get { if (dwMaster == null) return ""; return dwMaster["ART"].ToString(); } set { if (dwMaster == null) return; dwMaster["ART"] = value; OnPropertyChanged("ART", value); } } //lENGth 20
                public string VAR { get { if (dwMaster == null) return ""; return dwMaster["VAR"].ToString(); } set { if (dwMaster == null) return; dwMaster["VAR"] = value; OnPropertyChanged("VAR", value); } } //lENGth 3
                public string FARBE { get { if (dwMaster == null) return ""; return dwMaster["FARBE"].ToString(); } set { if (dwMaster == null) return; dwMaster["FARBE"] = value; OnPropertyChanged("FARBE", value); } } //lENGth 10
                public string FINISH { get { if (dwMaster == null) return ""; return dwMaster["FINISH"].ToString(); } set { if (dwMaster == null) return; dwMaster["FINISH"] = value; OnPropertyChanged("FINISH", value); } } //lENGth 10
                public string DESS { get { if (dwMaster == null) return ""; return dwMaster["DESS"].ToString(); } set { if (dwMaster == null) return; dwMaster["DESS"] = value; OnPropertyChanged("DESS", value); } } //lENGth 10
                public string COLORIT { get { if (dwMaster == null) return ""; return dwMaster["COLORIT"].ToString(); } set { if (dwMaster == null) return; dwMaster["COLORIT"] = value; OnPropertyChanged("COLORIT", value); } } //lENGth 10
                public string QITABLE { get { if (dwMaster == null) return ""; return dwMaster["QITABLE"].ToString(); } set { if (dwMaster == null) return; dwMaster["QITABLE"] = value; OnPropertyChanged("QITABLE", value); } } //lENGth 8
                public string RWKRS { get { if (dwMaster == null) return ""; return dwMaster["RWKRS"].ToString(); } set { if (dwMaster == null) return; dwMaster["RWKRS"] = value; OnPropertyChanged("RWKRS", value); } } //lENGth 2
                public string RWLFD { get { if (dwMaster == null) return ""; return dwMaster["RWLFD"].ToString(); } set { if (dwMaster == null) return; dwMaster["RWLFD"] = value; OnPropertyChanged("RWLFD", value); } } //lENGth 6
                public string RWPOS { get { if (dwMaster == null) return ""; return dwMaster["RWPOS"].ToString(); } set { if (dwMaster == null) return; dwMaster["RWPOS"] = value; OnPropertyChanged("RWPOS", value); } } //lENGth 4
                public string STKNR { get { if (dwMaster == null) return ""; return dwMaster["STKNR"].ToString(); } set { if (dwMaster == null) return; dwMaster["STKNR"] = value; OnPropertyChanged("STKNR", value); } } //lENGth 12
                public double MQTY { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["MQTY"].ToString()); } set { if (dwMaster == null) return; dwMaster["MQTY"] = value; OnPropertyChanged("MQTY", value); } } //lENGth 0
                public double KGQTY { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["KGQTY"].ToString()); } set { if (dwMaster == null) return; dwMaster["KGQTY"] = value; OnPropertyChanged("KGQTY", value); } } //lENGth 0
                public string QLV { get { if (dwMaster == null) return ""; return dwMaster["QLV"].ToString(); } set { if (dwMaster == null) return; dwMaster["QLV"] = value; OnPropertyChanged("QLV", value); } } //lENGth 2
                public double ER000 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER000"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER000"] = value; OnPropertyChanged("ER000", value); } } //lENGth 0
                public double ER001 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER001"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER001"] = value; OnPropertyChanged("ER001", value); } } //lENGth 0
                public double ER002 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER002"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER002"] = value; OnPropertyChanged("ER002", value); } } //lENGth 0
                public double ER003 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER003"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER003"] = value; OnPropertyChanged("ER003", value); } } //lENGth 0
                public double ER004 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER004"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER004"] = value; OnPropertyChanged("ER004", value); } } //lENGth 0
                public double ER005 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER005"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER005"] = value; OnPropertyChanged("ER005", value); } } //lENGth 0
                public double ER006 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER006"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER006"] = value; OnPropertyChanged("ER006", value); } } //lENGth 0
                public double ER007 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER007"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER007"] = value; OnPropertyChanged("ER007", value); } } //lENGth 0
                public double ER008 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER008"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER008"] = value; OnPropertyChanged("ER008", value); } } //lENGth 0
                public double ER009 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER009"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER009"] = value; OnPropertyChanged("ER009", value); } } //lENGth 0
                public double ER010 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER010"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER010"] = value; OnPropertyChanged("ER010", value); } } //lENGth 0
                public double ER011 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER011"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER011"] = value; OnPropertyChanged("ER011", value); } } //lENGth 0
                public double ER012 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER012"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER012"] = value; OnPropertyChanged("ER012", value); } } //lENGth 0
                public double ER013 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER013"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER013"] = value; OnPropertyChanged("ER013", value); } } //lENGth 0
                public double ER014 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER014"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER014"] = value; OnPropertyChanged("ER014", value); } } //lENGth 0
                public double ER015 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER015"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER015"] = value; OnPropertyChanged("ER015", value); } } //lENGth 0
                public double ER016 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER016"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER016"] = value; OnPropertyChanged("ER016", value); } } //lENGth 0
                public double ER017 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER017"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER017"] = value; OnPropertyChanged("ER017", value); } } //lENGth 0
                public double ER018 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER018"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER018"] = value; OnPropertyChanged("ER018", value); } } //lENGth 0
                public double ER019 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER019"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER019"] = value; OnPropertyChanged("ER019", value); } } //lENGth 0
                public double ER020 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER020"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER020"] = value; OnPropertyChanged("ER020", value); } } //lENGth 0
                public double ER021 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER021"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER021"] = value; OnPropertyChanged("ER021", value); } } //lENGth 0
                public double ER022 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER022"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER022"] = value; OnPropertyChanged("ER022", value); } } //lENGth 0
                public double ER023 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER023"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER023"] = value; OnPropertyChanged("ER023", value); } } //lENGth 0
                public double ER024 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER024"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER024"] = value; OnPropertyChanged("ER024", value); } } //lENGth 0
                public double ER025 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER025"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER025"] = value; OnPropertyChanged("ER025", value); } } //lENGth 0
                public double ER026 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER026"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER026"] = value; OnPropertyChanged("ER026", value); } } //lENGth 0
                public double ER027 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER027"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER027"] = value; OnPropertyChanged("ER027", value); } } //lENGth 0
                public double ER028 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER028"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER028"] = value; OnPropertyChanged("ER028", value); } } //lENGth 0
                public double ER029 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER029"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER029"] = value; OnPropertyChanged("ER029", value); } } //lENGth 0
                public double ER030 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER030"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER030"] = value; OnPropertyChanged("ER030", value); } } //lENGth 0
                public double ER031 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER031"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER031"] = value; OnPropertyChanged("ER031", value); } } //lENGth 0
                public double ER032 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER032"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER032"] = value; OnPropertyChanged("ER032", value); } } //lENGth 0
                public double ER033 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER033"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER033"] = value; OnPropertyChanged("ER033", value); } } //lENGth 0
                public double ER034 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER034"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER034"] = value; OnPropertyChanged("ER034", value); } } //lENGth 0
                public double ER035 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER035"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER035"] = value; OnPropertyChanged("ER035", value); } } //lENGth 0
                public double ER036 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER036"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER036"] = value; OnPropertyChanged("ER036", value); } } //lENGth 0
                public double ER037 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER037"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER037"] = value; OnPropertyChanged("ER037", value); } } //lENGth 0
                public double ER038 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER038"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER038"] = value; OnPropertyChanged("ER038", value); } } //lENGth 0
                public double ER039 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER039"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER039"] = value; OnPropertyChanged("ER039", value); } } //lENGth 0
                public double ER040 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER040"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER040"] = value; OnPropertyChanged("ER040", value); } } //lENGth 0
                public double ER041 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER041"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER041"] = value; OnPropertyChanged("ER041", value); } } //lENGth 0
                public double ER042 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER042"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER042"] = value; OnPropertyChanged("ER042", value); } } //lENGth 0
                public double ER043 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER043"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER043"] = value; OnPropertyChanged("ER043", value); } } //lENGth 0
                public double ER044 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER044"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER044"] = value; OnPropertyChanged("ER044", value); } } //lENGth 0
                public double ER045 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER045"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER045"] = value; OnPropertyChanged("ER045", value); } } //lENGth 0
                public double ER046 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER046"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER046"] = value; OnPropertyChanged("ER046", value); } } //lENGth 0
                public double ER047 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER047"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER047"] = value; OnPropertyChanged("ER047", value); } } //lENGth 0
                public double ER048 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER048"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER048"] = value; OnPropertyChanged("ER048", value); } } //lENGth 0
                public double ER049 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER049"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER049"] = value; OnPropertyChanged("ER049", value); } } //lENGth 0
                public double ER050 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER050"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER050"] = value; OnPropertyChanged("ER050", value); } } //lENGth 0
                public double ER051 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER051"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER051"] = value; OnPropertyChanged("ER051", value); } } //lENGth 0
                public double ER052 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER052"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER052"] = value; OnPropertyChanged("ER052", value); } } //lENGth 0
                public double ER053 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER053"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER053"] = value; OnPropertyChanged("ER053", value); } } //lENGth 0
                public double ER054 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER054"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER054"] = value; OnPropertyChanged("ER054", value); } } //lENGth 0
                public double ER055 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER055"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER055"] = value; OnPropertyChanged("ER055", value); } } //lENGth 0
                public double ER056 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER056"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER056"] = value; OnPropertyChanged("ER056", value); } } //lENGth 0
                public double ER057 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER057"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER057"] = value; OnPropertyChanged("ER057", value); } } //lENGth 0
                public double ER058 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER058"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER058"] = value; OnPropertyChanged("ER058", value); } } //lENGth 0
                public double ER059 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER059"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER059"] = value; OnPropertyChanged("ER059", value); } } //lENGth 0
                public double ER060 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER060"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER060"] = value; OnPropertyChanged("ER060", value); } } //lENGth 0
                public double ER061 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER061"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER061"] = value; OnPropertyChanged("ER061", value); } } //lENGth 0
                public double ER062 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER062"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER062"] = value; OnPropertyChanged("ER062", value); } } //lENGth 0
                public double ER063 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER063"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER063"] = value; OnPropertyChanged("ER063", value); } } //lENGth 0
                public double ER064 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER064"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER064"] = value; OnPropertyChanged("ER064", value); } } //lENGth 0
                public double ER065 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER065"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER065"] = value; OnPropertyChanged("ER065", value); } } //lENGth 0
                public double ER066 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER066"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER066"] = value; OnPropertyChanged("ER066", value); } } //lENGth 0
                public double ER067 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER067"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER067"] = value; OnPropertyChanged("ER067", value); } } //lENGth 0
                public double ER068 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER068"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER068"] = value; OnPropertyChanged("ER068", value); } } //lENGth 0
                public double ER069 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER069"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER069"] = value; OnPropertyChanged("ER069", value); } } //lENGth 0
                public double ER070 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER070"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER070"] = value; OnPropertyChanged("ER070", value); } } //lENGth 0
                public double ER071 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER071"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER071"] = value; OnPropertyChanged("ER071", value); } } //lENGth 0
                public double ER072 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER072"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER072"] = value; OnPropertyChanged("ER072", value); } } //lENGth 0
                public double ER073 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER073"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER073"] = value; OnPropertyChanged("ER073", value); } } //lENGth 0
                public double ER074 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER074"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER074"] = value; OnPropertyChanged("ER074", value); } } //lENGth 0
                public double ER075 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER075"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER075"] = value; OnPropertyChanged("ER075", value); } } //lENGth 0
                public double ER076 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER076"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER076"] = value; OnPropertyChanged("ER076", value); } } //lENGth 0
                public double ER077 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER077"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER077"] = value; OnPropertyChanged("ER077", value); } } //lENGth 0
                public double ER078 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER078"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER078"] = value; OnPropertyChanged("ER078", value); } } //lENGth 0
                public double ER079 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER079"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER079"] = value; OnPropertyChanged("ER079", value); } } //lENGth 0
                public double ER080 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER080"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER080"] = value; OnPropertyChanged("ER080", value); } } //lENGth 0
                public double ER081 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER081"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER081"] = value; OnPropertyChanged("ER081", value); } } //lENGth 0
                public double ER082 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER082"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER082"] = value; OnPropertyChanged("ER082", value); } } //lENGth 0
                public double ER083 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER083"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER083"] = value; OnPropertyChanged("ER083", value); } } //lENGth 0
                public double ER084 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER084"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER084"] = value; OnPropertyChanged("ER084", value); } } //lENGth 0
                public double ER085 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER085"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER085"] = value; OnPropertyChanged("ER085", value); } } //lENGth 0
                public double ER086 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER086"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER086"] = value; OnPropertyChanged("ER086", value); } } //lENGth 0
                public double ER087 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER087"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER087"] = value; OnPropertyChanged("ER087", value); } } //lENGth 0
                public double ER088 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER088"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER088"] = value; OnPropertyChanged("ER088", value); } } //lENGth 0
                public double ER089 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER089"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER089"] = value; OnPropertyChanged("ER089", value); } } //lENGth 0
                public double ER090 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER090"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER090"] = value; OnPropertyChanged("ER090", value); } } //lENGth 0
                public double ER091 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER091"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER091"] = value; OnPropertyChanged("ER091", value); } } //lENGth 0
                public double ER092 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER092"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER092"] = value; OnPropertyChanged("ER092", value); } } //lENGth 0
                public double ER093 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER093"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER093"] = value; OnPropertyChanged("ER093", value); } } //lENGth 0
                public double ER094 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER094"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER094"] = value; OnPropertyChanged("ER094", value); } } //lENGth 0
                public double ER095 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER095"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER095"] = value; OnPropertyChanged("ER095", value); } } //lENGth 0
                public double ER096 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER096"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER096"] = value; OnPropertyChanged("ER096", value); } } //lENGth 0
                public double ER097 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER097"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER097"] = value; OnPropertyChanged("ER097", value); } } //lENGth 0
                public double ER098 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER098"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER098"] = value; OnPropertyChanged("ER098", value); } } //lENGth 0
                public double ER099 { get { if (dwMaster == null) return 0.0; return  Convert.ToDouble(dwMaster["ER099"].ToString()); } set { if (dwMaster == null) return; dwMaster["ER099"] = value; OnPropertyChanged("ER099", value); } } //lENGth 0
       */
       #endregion
    } 
       public partial class UIICC_WBERROR
    {
      
        #region======ColumnSchema==========
       /*
       #region ==MANDANT===========
        public static readonly DependencyProperty MANDANTProperty = DependencyProperty.Register("MANDANT",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnMANDANTChanged));
        public string MANDANT
        {
            get
            {
                return (string)GetValue(MANDANTProperty);
            }
            set
            {
                SetValue(MANDANTProperty, value);
                OnMANDANTChg();
            }
        }
        private static void OnMANDANTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.MANDANT = (string)e.NewValue;
            }
        }
        public virtual void OnMANDANTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.MANDANT=MANDANT;
        }
         #endregion
       #region ==LO===========
        public static readonly DependencyProperty LOProperty = DependencyProperty.Register("LO",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnLOChanged));
        public string LO
        {
            get
            {
                return (string)GetValue(LOProperty);
            }
            set
            {
                SetValue(LOProperty, value);
                OnLOChg();
            }
        }
        private static void OnLOChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.LO = (string)e.NewValue;
            }
        }
        public virtual void OnLOChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.LO=LO;
        }
         #endregion
       #region ==LB===========
        public static readonly DependencyProperty LBProperty = DependencyProperty.Register("LB",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnLBChanged));
        public string LB
        {
            get
            {
                return (string)GetValue(LBProperty);
            }
            set
            {
                SetValue(LBProperty, value);
                OnLBChg();
            }
        }
        private static void OnLBChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.LB = (string)e.NewValue;
            }
        }
        public virtual void OnLBChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.LB=LB;
        }
         #endregion
       #region ==MDATE===========
        public static readonly DependencyProperty MDATEProperty = DependencyProperty.Register("MDATE",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnMDATEChanged));
        public string MDATE
        {
            get
            {
                return (string)GetValue(MDATEProperty);
            }
            set
            {
                SetValue(MDATEProperty, value);
                OnMDATEChg();
            }
        }
        private static void OnMDATEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.MDATE = (string)e.NewValue;
            }
        }
        public virtual void OnMDATEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.MDATE=MDATE;
        }
         #endregion
       #region ==WAKZ===========
        public static readonly DependencyProperty WAKZProperty = DependencyProperty.Register("WAKZ",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnWAKZChanged));
        public string WAKZ
        {
            get
            {
                return (string)GetValue(WAKZProperty);
            }
            set
            {
                SetValue(WAKZProperty, value);
                OnWAKZChg();
            }
        }
        private static void OnWAKZChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.WAKZ = (string)e.NewValue;
            }
        }
        public virtual void OnWAKZChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.WAKZ=WAKZ;
        }
         #endregion
       #region ==ART===========
        public static readonly DependencyProperty ARTProperty = DependencyProperty.Register("ART",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnARTChanged));
        public string ART
        {
            get
            {
                return (string)GetValue(ARTProperty);
            }
            set
            {
                SetValue(ARTProperty, value);
                OnARTChg();
            }
        }
        private static void OnARTChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ART = (string)e.NewValue;
            }
        }
        public virtual void OnARTChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ART=ART;
        }
         #endregion
       #region ==VAR===========
        public static readonly DependencyProperty VARProperty = DependencyProperty.Register("VAR",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnVARChanged));
        public string VAR
        {
            get
            {
                return (string)GetValue(VARProperty);
            }
            set
            {
                SetValue(VARProperty, value);
                OnVARChg();
            }
        }
        private static void OnVARChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.VAR = (string)e.NewValue;
            }
        }
        public virtual void OnVARChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.VAR=VAR;
        }
         #endregion
       #region ==FARBE===========
        public static readonly DependencyProperty FARBEProperty = DependencyProperty.Register("FARBE",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnFARBEChanged));
        public string FARBE
        {
            get
            {
                return (string)GetValue(FARBEProperty);
            }
            set
            {
                SetValue(FARBEProperty, value);
                OnFARBEChg();
            }
        }
        private static void OnFARBEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.FARBE = (string)e.NewValue;
            }
        }
        public virtual void OnFARBEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.FARBE=FARBE;
        }
         #endregion
       #region ==FINISH===========
        public static readonly DependencyProperty FINISHProperty = DependencyProperty.Register("FINISH",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnFINISHChanged));
        public string FINISH
        {
            get
            {
                return (string)GetValue(FINISHProperty);
            }
            set
            {
                SetValue(FINISHProperty, value);
                OnFINISHChg();
            }
        }
        private static void OnFINISHChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.FINISH = (string)e.NewValue;
            }
        }
        public virtual void OnFINISHChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.FINISH=FINISH;
        }
         #endregion
       #region ==DESS===========
        public static readonly DependencyProperty DESSProperty = DependencyProperty.Register("DESS",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnDESSChanged));
        public string DESS
        {
            get
            {
                return (string)GetValue(DESSProperty);
            }
            set
            {
                SetValue(DESSProperty, value);
                OnDESSChg();
            }
        }
        private static void OnDESSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.DESS = (string)e.NewValue;
            }
        }
        public virtual void OnDESSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.DESS=DESS;
        }
         #endregion
       #region ==COLORIT===========
        public static readonly DependencyProperty COLORITProperty = DependencyProperty.Register("COLORIT",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnCOLORITChanged));
        public string COLORIT
        {
            get
            {
                return (string)GetValue(COLORITProperty);
            }
            set
            {
                SetValue(COLORITProperty, value);
                OnCOLORITChg();
            }
        }
        private static void OnCOLORITChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.COLORIT = (string)e.NewValue;
            }
        }
        public virtual void OnCOLORITChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.COLORIT=COLORIT;
        }
         #endregion
       #region ==QITABLE===========
        public static readonly DependencyProperty QITABLEProperty = DependencyProperty.Register("QITABLE",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnQITABLEChanged));
        public string QITABLE
        {
            get
            {
                return (string)GetValue(QITABLEProperty);
            }
            set
            {
                SetValue(QITABLEProperty, value);
                OnQITABLEChg();
            }
        }
        private static void OnQITABLEChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.QITABLE = (string)e.NewValue;
            }
        }
        public virtual void OnQITABLEChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.QITABLE=QITABLE;
        }
         #endregion
       #region ==RWKRS===========
        public static readonly DependencyProperty RWKRSProperty = DependencyProperty.Register("RWKRS",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnRWKRSChanged));
        public string RWKRS
        {
            get
            {
                return (string)GetValue(RWKRSProperty);
            }
            set
            {
                SetValue(RWKRSProperty, value);
                OnRWKRSChg();
            }
        }
        private static void OnRWKRSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.RWKRS = (string)e.NewValue;
            }
        }
        public virtual void OnRWKRSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.RWKRS=RWKRS;
        }
         #endregion
       #region ==RWLFD===========
        public static readonly DependencyProperty RWLFDProperty = DependencyProperty.Register("RWLFD",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnRWLFDChanged));
        public string RWLFD
        {
            get
            {
                return (string)GetValue(RWLFDProperty);
            }
            set
            {
                SetValue(RWLFDProperty, value);
                OnRWLFDChg();
            }
        }
        private static void OnRWLFDChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.RWLFD = (string)e.NewValue;
            }
        }
        public virtual void OnRWLFDChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.RWLFD=RWLFD;
        }
         #endregion
       #region ==RWPOS===========
        public static readonly DependencyProperty RWPOSProperty = DependencyProperty.Register("RWPOS",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnRWPOSChanged));
        public string RWPOS
        {
            get
            {
                return (string)GetValue(RWPOSProperty);
            }
            set
            {
                SetValue(RWPOSProperty, value);
                OnRWPOSChg();
            }
        }
        private static void OnRWPOSChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.RWPOS = (string)e.NewValue;
            }
        }
        public virtual void OnRWPOSChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.RWPOS=RWPOS;
        }
         #endregion
       #region ==STKNR===========
        public static readonly DependencyProperty STKNRProperty = DependencyProperty.Register("STKNR",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSTKNRChanged));
        public string STKNR
        {
            get
            {
                return (string)GetValue(STKNRProperty);
            }
            set
            {
                SetValue(STKNRProperty, value);
                OnSTKNRChg();
            }
        }
        private static void OnSTKNRChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.STKNR = (string)e.NewValue;
            }
        }
        public virtual void OnSTKNRChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.STKNR=STKNR;
        }
         #endregion
       #region ==MQTY===========
        public static readonly DependencyProperty MQTYProperty = DependencyProperty.Register("MQTY",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnMQTYChanged));
        public string MQTY
        {
            get
            {
                return (string)GetValue(MQTYProperty);
            }
            set
            {
                SetValue(MQTYProperty, value);
                OnMQTYChg();
            }
        }
        private static void OnMQTYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.MQTY = (string)e.NewValue;
            }
        }
        public virtual void OnMQTYChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.MQTY=MQTY;
        }
         #endregion
       #region ==KGQTY===========
        public static readonly DependencyProperty KGQTYProperty = DependencyProperty.Register("KGQTY",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnKGQTYChanged));
        public string KGQTY
        {
            get
            {
                return (string)GetValue(KGQTYProperty);
            }
            set
            {
                SetValue(KGQTYProperty, value);
                OnKGQTYChg();
            }
        }
        private static void OnKGQTYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.KGQTY = (string)e.NewValue;
            }
        }
        public virtual void OnKGQTYChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.KGQTY=KGQTY;
        }
         #endregion
       #region ==QLV===========
        public static readonly DependencyProperty QLVProperty = DependencyProperty.Register("QLV",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnQLVChanged));
        public string QLV
        {
            get
            {
                return (string)GetValue(QLVProperty);
            }
            set
            {
                SetValue(QLVProperty, value);
                OnQLVChg();
            }
        }
        private static void OnQLVChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.QLV = (string)e.NewValue;
            }
        }
        public virtual void OnQLVChg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.QLV=QLV;
        }
         #endregion
       #region ==ER000===========
        public static readonly DependencyProperty ER000Property = DependencyProperty.Register("ER000",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER000Changed));
        public string ER000
        {
            get
            {
                return (string)GetValue(ER000Property);
            }
            set
            {
                SetValue(ER000Property, value);
                OnER000Chg();
            }
        }
        private static void OnER000Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER000 = (string)e.NewValue;
            }
        }
        public virtual void OnER000Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER000=ER000;
        }
         #endregion
       #region ==ER001===========
        public static readonly DependencyProperty ER001Property = DependencyProperty.Register("ER001",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER001Changed));
        public string ER001
        {
            get
            {
                return (string)GetValue(ER001Property);
            }
            set
            {
                SetValue(ER001Property, value);
                OnER001Chg();
            }
        }
        private static void OnER001Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER001 = (string)e.NewValue;
            }
        }
        public virtual void OnER001Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER001=ER001;
        }
         #endregion
       #region ==ER002===========
        public static readonly DependencyProperty ER002Property = DependencyProperty.Register("ER002",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER002Changed));
        public string ER002
        {
            get
            {
                return (string)GetValue(ER002Property);
            }
            set
            {
                SetValue(ER002Property, value);
                OnER002Chg();
            }
        }
        private static void OnER002Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER002 = (string)e.NewValue;
            }
        }
        public virtual void OnER002Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER002=ER002;
        }
         #endregion
       #region ==ER003===========
        public static readonly DependencyProperty ER003Property = DependencyProperty.Register("ER003",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER003Changed));
        public string ER003
        {
            get
            {
                return (string)GetValue(ER003Property);
            }
            set
            {
                SetValue(ER003Property, value);
                OnER003Chg();
            }
        }
        private static void OnER003Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER003 = (string)e.NewValue;
            }
        }
        public virtual void OnER003Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER003=ER003;
        }
         #endregion
       #region ==ER004===========
        public static readonly DependencyProperty ER004Property = DependencyProperty.Register("ER004",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER004Changed));
        public string ER004
        {
            get
            {
                return (string)GetValue(ER004Property);
            }
            set
            {
                SetValue(ER004Property, value);
                OnER004Chg();
            }
        }
        private static void OnER004Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER004 = (string)e.NewValue;
            }
        }
        public virtual void OnER004Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER004=ER004;
        }
         #endregion
       #region ==ER005===========
        public static readonly DependencyProperty ER005Property = DependencyProperty.Register("ER005",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER005Changed));
        public string ER005
        {
            get
            {
                return (string)GetValue(ER005Property);
            }
            set
            {
                SetValue(ER005Property, value);
                OnER005Chg();
            }
        }
        private static void OnER005Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER005 = (string)e.NewValue;
            }
        }
        public virtual void OnER005Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER005=ER005;
        }
         #endregion
       #region ==ER006===========
        public static readonly DependencyProperty ER006Property = DependencyProperty.Register("ER006",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER006Changed));
        public string ER006
        {
            get
            {
                return (string)GetValue(ER006Property);
            }
            set
            {
                SetValue(ER006Property, value);
                OnER006Chg();
            }
        }
        private static void OnER006Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER006 = (string)e.NewValue;
            }
        }
        public virtual void OnER006Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER006=ER006;
        }
         #endregion
       #region ==ER007===========
        public static readonly DependencyProperty ER007Property = DependencyProperty.Register("ER007",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER007Changed));
        public string ER007
        {
            get
            {
                return (string)GetValue(ER007Property);
            }
            set
            {
                SetValue(ER007Property, value);
                OnER007Chg();
            }
        }
        private static void OnER007Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER007 = (string)e.NewValue;
            }
        }
        public virtual void OnER007Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER007=ER007;
        }
         #endregion
       #region ==ER008===========
        public static readonly DependencyProperty ER008Property = DependencyProperty.Register("ER008",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER008Changed));
        public string ER008
        {
            get
            {
                return (string)GetValue(ER008Property);
            }
            set
            {
                SetValue(ER008Property, value);
                OnER008Chg();
            }
        }
        private static void OnER008Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER008 = (string)e.NewValue;
            }
        }
        public virtual void OnER008Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER008=ER008;
        }
         #endregion
       #region ==ER009===========
        public static readonly DependencyProperty ER009Property = DependencyProperty.Register("ER009",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER009Changed));
        public string ER009
        {
            get
            {
                return (string)GetValue(ER009Property);
            }
            set
            {
                SetValue(ER009Property, value);
                OnER009Chg();
            }
        }
        private static void OnER009Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER009 = (string)e.NewValue;
            }
        }
        public virtual void OnER009Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER009=ER009;
        }
         #endregion
       #region ==ER010===========
        public static readonly DependencyProperty ER010Property = DependencyProperty.Register("ER010",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER010Changed));
        public string ER010
        {
            get
            {
                return (string)GetValue(ER010Property);
            }
            set
            {
                SetValue(ER010Property, value);
                OnER010Chg();
            }
        }
        private static void OnER010Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER010 = (string)e.NewValue;
            }
        }
        public virtual void OnER010Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER010=ER010;
        }
         #endregion
       #region ==ER011===========
        public static readonly DependencyProperty ER011Property = DependencyProperty.Register("ER011",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER011Changed));
        public string ER011
        {
            get
            {
                return (string)GetValue(ER011Property);
            }
            set
            {
                SetValue(ER011Property, value);
                OnER011Chg();
            }
        }
        private static void OnER011Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER011 = (string)e.NewValue;
            }
        }
        public virtual void OnER011Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER011=ER011;
        }
         #endregion
       #region ==ER012===========
        public static readonly DependencyProperty ER012Property = DependencyProperty.Register("ER012",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER012Changed));
        public string ER012
        {
            get
            {
                return (string)GetValue(ER012Property);
            }
            set
            {
                SetValue(ER012Property, value);
                OnER012Chg();
            }
        }
        private static void OnER012Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER012 = (string)e.NewValue;
            }
        }
        public virtual void OnER012Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER012=ER012;
        }
         #endregion
       #region ==ER013===========
        public static readonly DependencyProperty ER013Property = DependencyProperty.Register("ER013",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER013Changed));
        public string ER013
        {
            get
            {
                return (string)GetValue(ER013Property);
            }
            set
            {
                SetValue(ER013Property, value);
                OnER013Chg();
            }
        }
        private static void OnER013Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER013 = (string)e.NewValue;
            }
        }
        public virtual void OnER013Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER013=ER013;
        }
         #endregion
       #region ==ER014===========
        public static readonly DependencyProperty ER014Property = DependencyProperty.Register("ER014",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER014Changed));
        public string ER014
        {
            get
            {
                return (string)GetValue(ER014Property);
            }
            set
            {
                SetValue(ER014Property, value);
                OnER014Chg();
            }
        }
        private static void OnER014Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER014 = (string)e.NewValue;
            }
        }
        public virtual void OnER014Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER014=ER014;
        }
         #endregion
       #region ==ER015===========
        public static readonly DependencyProperty ER015Property = DependencyProperty.Register("ER015",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER015Changed));
        public string ER015
        {
            get
            {
                return (string)GetValue(ER015Property);
            }
            set
            {
                SetValue(ER015Property, value);
                OnER015Chg();
            }
        }
        private static void OnER015Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER015 = (string)e.NewValue;
            }
        }
        public virtual void OnER015Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER015=ER015;
        }
         #endregion
       #region ==ER016===========
        public static readonly DependencyProperty ER016Property = DependencyProperty.Register("ER016",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER016Changed));
        public string ER016
        {
            get
            {
                return (string)GetValue(ER016Property);
            }
            set
            {
                SetValue(ER016Property, value);
                OnER016Chg();
            }
        }
        private static void OnER016Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER016 = (string)e.NewValue;
            }
        }
        public virtual void OnER016Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER016=ER016;
        }
         #endregion
       #region ==ER017===========
        public static readonly DependencyProperty ER017Property = DependencyProperty.Register("ER017",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER017Changed));
        public string ER017
        {
            get
            {
                return (string)GetValue(ER017Property);
            }
            set
            {
                SetValue(ER017Property, value);
                OnER017Chg();
            }
        }
        private static void OnER017Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER017 = (string)e.NewValue;
            }
        }
        public virtual void OnER017Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER017=ER017;
        }
         #endregion
       #region ==ER018===========
        public static readonly DependencyProperty ER018Property = DependencyProperty.Register("ER018",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER018Changed));
        public string ER018
        {
            get
            {
                return (string)GetValue(ER018Property);
            }
            set
            {
                SetValue(ER018Property, value);
                OnER018Chg();
            }
        }
        private static void OnER018Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER018 = (string)e.NewValue;
            }
        }
        public virtual void OnER018Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER018=ER018;
        }
         #endregion
       #region ==ER019===========
        public static readonly DependencyProperty ER019Property = DependencyProperty.Register("ER019",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER019Changed));
        public string ER019
        {
            get
            {
                return (string)GetValue(ER019Property);
            }
            set
            {
                SetValue(ER019Property, value);
                OnER019Chg();
            }
        }
        private static void OnER019Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER019 = (string)e.NewValue;
            }
        }
        public virtual void OnER019Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER019=ER019;
        }
         #endregion
       #region ==ER020===========
        public static readonly DependencyProperty ER020Property = DependencyProperty.Register("ER020",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER020Changed));
        public string ER020
        {
            get
            {
                return (string)GetValue(ER020Property);
            }
            set
            {
                SetValue(ER020Property, value);
                OnER020Chg();
            }
        }
        private static void OnER020Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER020 = (string)e.NewValue;
            }
        }
        public virtual void OnER020Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER020=ER020;
        }
         #endregion
       #region ==ER021===========
        public static readonly DependencyProperty ER021Property = DependencyProperty.Register("ER021",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER021Changed));
        public string ER021
        {
            get
            {
                return (string)GetValue(ER021Property);
            }
            set
            {
                SetValue(ER021Property, value);
                OnER021Chg();
            }
        }
        private static void OnER021Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER021 = (string)e.NewValue;
            }
        }
        public virtual void OnER021Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER021=ER021;
        }
         #endregion
       #region ==ER022===========
        public static readonly DependencyProperty ER022Property = DependencyProperty.Register("ER022",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER022Changed));
        public string ER022
        {
            get
            {
                return (string)GetValue(ER022Property);
            }
            set
            {
                SetValue(ER022Property, value);
                OnER022Chg();
            }
        }
        private static void OnER022Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER022 = (string)e.NewValue;
            }
        }
        public virtual void OnER022Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER022=ER022;
        }
         #endregion
       #region ==ER023===========
        public static readonly DependencyProperty ER023Property = DependencyProperty.Register("ER023",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER023Changed));
        public string ER023
        {
            get
            {
                return (string)GetValue(ER023Property);
            }
            set
            {
                SetValue(ER023Property, value);
                OnER023Chg();
            }
        }
        private static void OnER023Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER023 = (string)e.NewValue;
            }
        }
        public virtual void OnER023Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER023=ER023;
        }
         #endregion
       #region ==ER024===========
        public static readonly DependencyProperty ER024Property = DependencyProperty.Register("ER024",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER024Changed));
        public string ER024
        {
            get
            {
                return (string)GetValue(ER024Property);
            }
            set
            {
                SetValue(ER024Property, value);
                OnER024Chg();
            }
        }
        private static void OnER024Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER024 = (string)e.NewValue;
            }
        }
        public virtual void OnER024Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER024=ER024;
        }
         #endregion
       #region ==ER025===========
        public static readonly DependencyProperty ER025Property = DependencyProperty.Register("ER025",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER025Changed));
        public string ER025
        {
            get
            {
                return (string)GetValue(ER025Property);
            }
            set
            {
                SetValue(ER025Property, value);
                OnER025Chg();
            }
        }
        private static void OnER025Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER025 = (string)e.NewValue;
            }
        }
        public virtual void OnER025Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER025=ER025;
        }
         #endregion
       #region ==ER026===========
        public static readonly DependencyProperty ER026Property = DependencyProperty.Register("ER026",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER026Changed));
        public string ER026
        {
            get
            {
                return (string)GetValue(ER026Property);
            }
            set
            {
                SetValue(ER026Property, value);
                OnER026Chg();
            }
        }
        private static void OnER026Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER026 = (string)e.NewValue;
            }
        }
        public virtual void OnER026Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER026=ER026;
        }
         #endregion
       #region ==ER027===========
        public static readonly DependencyProperty ER027Property = DependencyProperty.Register("ER027",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER027Changed));
        public string ER027
        {
            get
            {
                return (string)GetValue(ER027Property);
            }
            set
            {
                SetValue(ER027Property, value);
                OnER027Chg();
            }
        }
        private static void OnER027Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER027 = (string)e.NewValue;
            }
        }
        public virtual void OnER027Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER027=ER027;
        }
         #endregion
       #region ==ER028===========
        public static readonly DependencyProperty ER028Property = DependencyProperty.Register("ER028",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER028Changed));
        public string ER028
        {
            get
            {
                return (string)GetValue(ER028Property);
            }
            set
            {
                SetValue(ER028Property, value);
                OnER028Chg();
            }
        }
        private static void OnER028Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER028 = (string)e.NewValue;
            }
        }
        public virtual void OnER028Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER028=ER028;
        }
         #endregion
       #region ==ER029===========
        public static readonly DependencyProperty ER029Property = DependencyProperty.Register("ER029",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER029Changed));
        public string ER029
        {
            get
            {
                return (string)GetValue(ER029Property);
            }
            set
            {
                SetValue(ER029Property, value);
                OnER029Chg();
            }
        }
        private static void OnER029Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER029 = (string)e.NewValue;
            }
        }
        public virtual void OnER029Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER029=ER029;
        }
         #endregion
       #region ==ER030===========
        public static readonly DependencyProperty ER030Property = DependencyProperty.Register("ER030",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER030Changed));
        public string ER030
        {
            get
            {
                return (string)GetValue(ER030Property);
            }
            set
            {
                SetValue(ER030Property, value);
                OnER030Chg();
            }
        }
        private static void OnER030Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER030 = (string)e.NewValue;
            }
        }
        public virtual void OnER030Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER030=ER030;
        }
         #endregion
       #region ==ER031===========
        public static readonly DependencyProperty ER031Property = DependencyProperty.Register("ER031",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER031Changed));
        public string ER031
        {
            get
            {
                return (string)GetValue(ER031Property);
            }
            set
            {
                SetValue(ER031Property, value);
                OnER031Chg();
            }
        }
        private static void OnER031Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER031 = (string)e.NewValue;
            }
        }
        public virtual void OnER031Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER031=ER031;
        }
         #endregion
       #region ==ER032===========
        public static readonly DependencyProperty ER032Property = DependencyProperty.Register("ER032",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER032Changed));
        public string ER032
        {
            get
            {
                return (string)GetValue(ER032Property);
            }
            set
            {
                SetValue(ER032Property, value);
                OnER032Chg();
            }
        }
        private static void OnER032Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER032 = (string)e.NewValue;
            }
        }
        public virtual void OnER032Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER032=ER032;
        }
         #endregion
       #region ==ER033===========
        public static readonly DependencyProperty ER033Property = DependencyProperty.Register("ER033",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER033Changed));
        public string ER033
        {
            get
            {
                return (string)GetValue(ER033Property);
            }
            set
            {
                SetValue(ER033Property, value);
                OnER033Chg();
            }
        }
        private static void OnER033Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER033 = (string)e.NewValue;
            }
        }
        public virtual void OnER033Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER033=ER033;
        }
         #endregion
       #region ==ER034===========
        public static readonly DependencyProperty ER034Property = DependencyProperty.Register("ER034",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER034Changed));
        public string ER034
        {
            get
            {
                return (string)GetValue(ER034Property);
            }
            set
            {
                SetValue(ER034Property, value);
                OnER034Chg();
            }
        }
        private static void OnER034Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER034 = (string)e.NewValue;
            }
        }
        public virtual void OnER034Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER034=ER034;
        }
         #endregion
       #region ==ER035===========
        public static readonly DependencyProperty ER035Property = DependencyProperty.Register("ER035",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER035Changed));
        public string ER035
        {
            get
            {
                return (string)GetValue(ER035Property);
            }
            set
            {
                SetValue(ER035Property, value);
                OnER035Chg();
            }
        }
        private static void OnER035Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER035 = (string)e.NewValue;
            }
        }
        public virtual void OnER035Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER035=ER035;
        }
         #endregion
       #region ==ER036===========
        public static readonly DependencyProperty ER036Property = DependencyProperty.Register("ER036",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER036Changed));
        public string ER036
        {
            get
            {
                return (string)GetValue(ER036Property);
            }
            set
            {
                SetValue(ER036Property, value);
                OnER036Chg();
            }
        }
        private static void OnER036Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER036 = (string)e.NewValue;
            }
        }
        public virtual void OnER036Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER036=ER036;
        }
         #endregion
       #region ==ER037===========
        public static readonly DependencyProperty ER037Property = DependencyProperty.Register("ER037",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER037Changed));
        public string ER037
        {
            get
            {
                return (string)GetValue(ER037Property);
            }
            set
            {
                SetValue(ER037Property, value);
                OnER037Chg();
            }
        }
        private static void OnER037Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER037 = (string)e.NewValue;
            }
        }
        public virtual void OnER037Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER037=ER037;
        }
         #endregion
       #region ==ER038===========
        public static readonly DependencyProperty ER038Property = DependencyProperty.Register("ER038",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER038Changed));
        public string ER038
        {
            get
            {
                return (string)GetValue(ER038Property);
            }
            set
            {
                SetValue(ER038Property, value);
                OnER038Chg();
            }
        }
        private static void OnER038Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER038 = (string)e.NewValue;
            }
        }
        public virtual void OnER038Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER038=ER038;
        }
         #endregion
       #region ==ER039===========
        public static readonly DependencyProperty ER039Property = DependencyProperty.Register("ER039",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER039Changed));
        public string ER039
        {
            get
            {
                return (string)GetValue(ER039Property);
            }
            set
            {
                SetValue(ER039Property, value);
                OnER039Chg();
            }
        }
        private static void OnER039Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER039 = (string)e.NewValue;
            }
        }
        public virtual void OnER039Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER039=ER039;
        }
         #endregion
       #region ==ER040===========
        public static readonly DependencyProperty ER040Property = DependencyProperty.Register("ER040",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER040Changed));
        public string ER040
        {
            get
            {
                return (string)GetValue(ER040Property);
            }
            set
            {
                SetValue(ER040Property, value);
                OnER040Chg();
            }
        }
        private static void OnER040Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER040 = (string)e.NewValue;
            }
        }
        public virtual void OnER040Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER040=ER040;
        }
         #endregion
       #region ==ER041===========
        public static readonly DependencyProperty ER041Property = DependencyProperty.Register("ER041",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER041Changed));
        public string ER041
        {
            get
            {
                return (string)GetValue(ER041Property);
            }
            set
            {
                SetValue(ER041Property, value);
                OnER041Chg();
            }
        }
        private static void OnER041Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER041 = (string)e.NewValue;
            }
        }
        public virtual void OnER041Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER041=ER041;
        }
         #endregion
       #region ==ER042===========
        public static readonly DependencyProperty ER042Property = DependencyProperty.Register("ER042",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER042Changed));
        public string ER042
        {
            get
            {
                return (string)GetValue(ER042Property);
            }
            set
            {
                SetValue(ER042Property, value);
                OnER042Chg();
            }
        }
        private static void OnER042Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER042 = (string)e.NewValue;
            }
        }
        public virtual void OnER042Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER042=ER042;
        }
         #endregion
       #region ==ER043===========
        public static readonly DependencyProperty ER043Property = DependencyProperty.Register("ER043",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER043Changed));
        public string ER043
        {
            get
            {
                return (string)GetValue(ER043Property);
            }
            set
            {
                SetValue(ER043Property, value);
                OnER043Chg();
            }
        }
        private static void OnER043Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER043 = (string)e.NewValue;
            }
        }
        public virtual void OnER043Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER043=ER043;
        }
         #endregion
       #region ==ER044===========
        public static readonly DependencyProperty ER044Property = DependencyProperty.Register("ER044",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER044Changed));
        public string ER044
        {
            get
            {
                return (string)GetValue(ER044Property);
            }
            set
            {
                SetValue(ER044Property, value);
                OnER044Chg();
            }
        }
        private static void OnER044Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER044 = (string)e.NewValue;
            }
        }
        public virtual void OnER044Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER044=ER044;
        }
         #endregion
       #region ==ER045===========
        public static readonly DependencyProperty ER045Property = DependencyProperty.Register("ER045",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER045Changed));
        public string ER045
        {
            get
            {
                return (string)GetValue(ER045Property);
            }
            set
            {
                SetValue(ER045Property, value);
                OnER045Chg();
            }
        }
        private static void OnER045Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER045 = (string)e.NewValue;
            }
        }
        public virtual void OnER045Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER045=ER045;
        }
         #endregion
       #region ==ER046===========
        public static readonly DependencyProperty ER046Property = DependencyProperty.Register("ER046",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER046Changed));
        public string ER046
        {
            get
            {
                return (string)GetValue(ER046Property);
            }
            set
            {
                SetValue(ER046Property, value);
                OnER046Chg();
            }
        }
        private static void OnER046Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER046 = (string)e.NewValue;
            }
        }
        public virtual void OnER046Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER046=ER046;
        }
         #endregion
       #region ==ER047===========
        public static readonly DependencyProperty ER047Property = DependencyProperty.Register("ER047",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER047Changed));
        public string ER047
        {
            get
            {
                return (string)GetValue(ER047Property);
            }
            set
            {
                SetValue(ER047Property, value);
                OnER047Chg();
            }
        }
        private static void OnER047Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER047 = (string)e.NewValue;
            }
        }
        public virtual void OnER047Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER047=ER047;
        }
         #endregion
       #region ==ER048===========
        public static readonly DependencyProperty ER048Property = DependencyProperty.Register("ER048",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER048Changed));
        public string ER048
        {
            get
            {
                return (string)GetValue(ER048Property);
            }
            set
            {
                SetValue(ER048Property, value);
                OnER048Chg();
            }
        }
        private static void OnER048Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER048 = (string)e.NewValue;
            }
        }
        public virtual void OnER048Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER048=ER048;
        }
         #endregion
       #region ==ER049===========
        public static readonly DependencyProperty ER049Property = DependencyProperty.Register("ER049",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER049Changed));
        public string ER049
        {
            get
            {
                return (string)GetValue(ER049Property);
            }
            set
            {
                SetValue(ER049Property, value);
                OnER049Chg();
            }
        }
        private static void OnER049Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER049 = (string)e.NewValue;
            }
        }
        public virtual void OnER049Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER049=ER049;
        }
         #endregion
       #region ==ER050===========
        public static readonly DependencyProperty ER050Property = DependencyProperty.Register("ER050",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER050Changed));
        public string ER050
        {
            get
            {
                return (string)GetValue(ER050Property);
            }
            set
            {
                SetValue(ER050Property, value);
                OnER050Chg();
            }
        }
        private static void OnER050Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER050 = (string)e.NewValue;
            }
        }
        public virtual void OnER050Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER050=ER050;
        }
         #endregion
       #region ==ER051===========
        public static readonly DependencyProperty ER051Property = DependencyProperty.Register("ER051",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER051Changed));
        public string ER051
        {
            get
            {
                return (string)GetValue(ER051Property);
            }
            set
            {
                SetValue(ER051Property, value);
                OnER051Chg();
            }
        }
        private static void OnER051Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER051 = (string)e.NewValue;
            }
        }
        public virtual void OnER051Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER051=ER051;
        }
         #endregion
       #region ==ER052===========
        public static readonly DependencyProperty ER052Property = DependencyProperty.Register("ER052",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER052Changed));
        public string ER052
        {
            get
            {
                return (string)GetValue(ER052Property);
            }
            set
            {
                SetValue(ER052Property, value);
                OnER052Chg();
            }
        }
        private static void OnER052Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER052 = (string)e.NewValue;
            }
        }
        public virtual void OnER052Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER052=ER052;
        }
         #endregion
       #region ==ER053===========
        public static readonly DependencyProperty ER053Property = DependencyProperty.Register("ER053",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER053Changed));
        public string ER053
        {
            get
            {
                return (string)GetValue(ER053Property);
            }
            set
            {
                SetValue(ER053Property, value);
                OnER053Chg();
            }
        }
        private static void OnER053Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER053 = (string)e.NewValue;
            }
        }
        public virtual void OnER053Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER053=ER053;
        }
         #endregion
       #region ==ER054===========
        public static readonly DependencyProperty ER054Property = DependencyProperty.Register("ER054",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER054Changed));
        public string ER054
        {
            get
            {
                return (string)GetValue(ER054Property);
            }
            set
            {
                SetValue(ER054Property, value);
                OnER054Chg();
            }
        }
        private static void OnER054Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER054 = (string)e.NewValue;
            }
        }
        public virtual void OnER054Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER054=ER054;
        }
         #endregion
       #region ==ER055===========
        public static readonly DependencyProperty ER055Property = DependencyProperty.Register("ER055",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER055Changed));
        public string ER055
        {
            get
            {
                return (string)GetValue(ER055Property);
            }
            set
            {
                SetValue(ER055Property, value);
                OnER055Chg();
            }
        }
        private static void OnER055Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER055 = (string)e.NewValue;
            }
        }
        public virtual void OnER055Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER055=ER055;
        }
         #endregion
       #region ==ER056===========
        public static readonly DependencyProperty ER056Property = DependencyProperty.Register("ER056",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER056Changed));
        public string ER056
        {
            get
            {
                return (string)GetValue(ER056Property);
            }
            set
            {
                SetValue(ER056Property, value);
                OnER056Chg();
            }
        }
        private static void OnER056Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER056 = (string)e.NewValue;
            }
        }
        public virtual void OnER056Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER056=ER056;
        }
         #endregion
       #region ==ER057===========
        public static readonly DependencyProperty ER057Property = DependencyProperty.Register("ER057",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER057Changed));
        public string ER057
        {
            get
            {
                return (string)GetValue(ER057Property);
            }
            set
            {
                SetValue(ER057Property, value);
                OnER057Chg();
            }
        }
        private static void OnER057Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER057 = (string)e.NewValue;
            }
        }
        public virtual void OnER057Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER057=ER057;
        }
         #endregion
       #region ==ER058===========
        public static readonly DependencyProperty ER058Property = DependencyProperty.Register("ER058",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER058Changed));
        public string ER058
        {
            get
            {
                return (string)GetValue(ER058Property);
            }
            set
            {
                SetValue(ER058Property, value);
                OnER058Chg();
            }
        }
        private static void OnER058Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER058 = (string)e.NewValue;
            }
        }
        public virtual void OnER058Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER058=ER058;
        }
         #endregion
       #region ==ER059===========
        public static readonly DependencyProperty ER059Property = DependencyProperty.Register("ER059",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER059Changed));
        public string ER059
        {
            get
            {
                return (string)GetValue(ER059Property);
            }
            set
            {
                SetValue(ER059Property, value);
                OnER059Chg();
            }
        }
        private static void OnER059Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER059 = (string)e.NewValue;
            }
        }
        public virtual void OnER059Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER059=ER059;
        }
         #endregion
       #region ==ER060===========
        public static readonly DependencyProperty ER060Property = DependencyProperty.Register("ER060",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER060Changed));
        public string ER060
        {
            get
            {
                return (string)GetValue(ER060Property);
            }
            set
            {
                SetValue(ER060Property, value);
                OnER060Chg();
            }
        }
        private static void OnER060Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER060 = (string)e.NewValue;
            }
        }
        public virtual void OnER060Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER060=ER060;
        }
         #endregion
       #region ==ER061===========
        public static readonly DependencyProperty ER061Property = DependencyProperty.Register("ER061",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER061Changed));
        public string ER061
        {
            get
            {
                return (string)GetValue(ER061Property);
            }
            set
            {
                SetValue(ER061Property, value);
                OnER061Chg();
            }
        }
        private static void OnER061Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER061 = (string)e.NewValue;
            }
        }
        public virtual void OnER061Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER061=ER061;
        }
         #endregion
       #region ==ER062===========
        public static readonly DependencyProperty ER062Property = DependencyProperty.Register("ER062",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER062Changed));
        public string ER062
        {
            get
            {
                return (string)GetValue(ER062Property);
            }
            set
            {
                SetValue(ER062Property, value);
                OnER062Chg();
            }
        }
        private static void OnER062Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER062 = (string)e.NewValue;
            }
        }
        public virtual void OnER062Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER062=ER062;
        }
         #endregion
       #region ==ER063===========
        public static readonly DependencyProperty ER063Property = DependencyProperty.Register("ER063",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER063Changed));
        public string ER063
        {
            get
            {
                return (string)GetValue(ER063Property);
            }
            set
            {
                SetValue(ER063Property, value);
                OnER063Chg();
            }
        }
        private static void OnER063Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER063 = (string)e.NewValue;
            }
        }
        public virtual void OnER063Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER063=ER063;
        }
         #endregion
       #region ==ER064===========
        public static readonly DependencyProperty ER064Property = DependencyProperty.Register("ER064",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER064Changed));
        public string ER064
        {
            get
            {
                return (string)GetValue(ER064Property);
            }
            set
            {
                SetValue(ER064Property, value);
                OnER064Chg();
            }
        }
        private static void OnER064Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER064 = (string)e.NewValue;
            }
        }
        public virtual void OnER064Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER064=ER064;
        }
         #endregion
       #region ==ER065===========
        public static readonly DependencyProperty ER065Property = DependencyProperty.Register("ER065",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER065Changed));
        public string ER065
        {
            get
            {
                return (string)GetValue(ER065Property);
            }
            set
            {
                SetValue(ER065Property, value);
                OnER065Chg();
            }
        }
        private static void OnER065Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER065 = (string)e.NewValue;
            }
        }
        public virtual void OnER065Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER065=ER065;
        }
         #endregion
       #region ==ER066===========
        public static readonly DependencyProperty ER066Property = DependencyProperty.Register("ER066",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER066Changed));
        public string ER066
        {
            get
            {
                return (string)GetValue(ER066Property);
            }
            set
            {
                SetValue(ER066Property, value);
                OnER066Chg();
            }
        }
        private static void OnER066Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER066 = (string)e.NewValue;
            }
        }
        public virtual void OnER066Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER066=ER066;
        }
         #endregion
       #region ==ER067===========
        public static readonly DependencyProperty ER067Property = DependencyProperty.Register("ER067",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER067Changed));
        public string ER067
        {
            get
            {
                return (string)GetValue(ER067Property);
            }
            set
            {
                SetValue(ER067Property, value);
                OnER067Chg();
            }
        }
        private static void OnER067Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER067 = (string)e.NewValue;
            }
        }
        public virtual void OnER067Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER067=ER067;
        }
         #endregion
       #region ==ER068===========
        public static readonly DependencyProperty ER068Property = DependencyProperty.Register("ER068",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER068Changed));
        public string ER068
        {
            get
            {
                return (string)GetValue(ER068Property);
            }
            set
            {
                SetValue(ER068Property, value);
                OnER068Chg();
            }
        }
        private static void OnER068Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER068 = (string)e.NewValue;
            }
        }
        public virtual void OnER068Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER068=ER068;
        }
         #endregion
       #region ==ER069===========
        public static readonly DependencyProperty ER069Property = DependencyProperty.Register("ER069",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER069Changed));
        public string ER069
        {
            get
            {
                return (string)GetValue(ER069Property);
            }
            set
            {
                SetValue(ER069Property, value);
                OnER069Chg();
            }
        }
        private static void OnER069Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER069 = (string)e.NewValue;
            }
        }
        public virtual void OnER069Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER069=ER069;
        }
         #endregion
       #region ==ER070===========
        public static readonly DependencyProperty ER070Property = DependencyProperty.Register("ER070",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER070Changed));
        public string ER070
        {
            get
            {
                return (string)GetValue(ER070Property);
            }
            set
            {
                SetValue(ER070Property, value);
                OnER070Chg();
            }
        }
        private static void OnER070Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER070 = (string)e.NewValue;
            }
        }
        public virtual void OnER070Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER070=ER070;
        }
         #endregion
       #region ==ER071===========
        public static readonly DependencyProperty ER071Property = DependencyProperty.Register("ER071",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER071Changed));
        public string ER071
        {
            get
            {
                return (string)GetValue(ER071Property);
            }
            set
            {
                SetValue(ER071Property, value);
                OnER071Chg();
            }
        }
        private static void OnER071Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER071 = (string)e.NewValue;
            }
        }
        public virtual void OnER071Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER071=ER071;
        }
         #endregion
       #region ==ER072===========
        public static readonly DependencyProperty ER072Property = DependencyProperty.Register("ER072",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER072Changed));
        public string ER072
        {
            get
            {
                return (string)GetValue(ER072Property);
            }
            set
            {
                SetValue(ER072Property, value);
                OnER072Chg();
            }
        }
        private static void OnER072Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER072 = (string)e.NewValue;
            }
        }
        public virtual void OnER072Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER072=ER072;
        }
         #endregion
       #region ==ER073===========
        public static readonly DependencyProperty ER073Property = DependencyProperty.Register("ER073",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER073Changed));
        public string ER073
        {
            get
            {
                return (string)GetValue(ER073Property);
            }
            set
            {
                SetValue(ER073Property, value);
                OnER073Chg();
            }
        }
        private static void OnER073Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER073 = (string)e.NewValue;
            }
        }
        public virtual void OnER073Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER073=ER073;
        }
         #endregion
       #region ==ER074===========
        public static readonly DependencyProperty ER074Property = DependencyProperty.Register("ER074",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER074Changed));
        public string ER074
        {
            get
            {
                return (string)GetValue(ER074Property);
            }
            set
            {
                SetValue(ER074Property, value);
                OnER074Chg();
            }
        }
        private static void OnER074Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER074 = (string)e.NewValue;
            }
        }
        public virtual void OnER074Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER074=ER074;
        }
         #endregion
       #region ==ER075===========
        public static readonly DependencyProperty ER075Property = DependencyProperty.Register("ER075",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER075Changed));
        public string ER075
        {
            get
            {
                return (string)GetValue(ER075Property);
            }
            set
            {
                SetValue(ER075Property, value);
                OnER075Chg();
            }
        }
        private static void OnER075Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER075 = (string)e.NewValue;
            }
        }
        public virtual void OnER075Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER075=ER075;
        }
         #endregion
       #region ==ER076===========
        public static readonly DependencyProperty ER076Property = DependencyProperty.Register("ER076",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER076Changed));
        public string ER076
        {
            get
            {
                return (string)GetValue(ER076Property);
            }
            set
            {
                SetValue(ER076Property, value);
                OnER076Chg();
            }
        }
        private static void OnER076Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER076 = (string)e.NewValue;
            }
        }
        public virtual void OnER076Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER076=ER076;
        }
         #endregion
       #region ==ER077===========
        public static readonly DependencyProperty ER077Property = DependencyProperty.Register("ER077",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER077Changed));
        public string ER077
        {
            get
            {
                return (string)GetValue(ER077Property);
            }
            set
            {
                SetValue(ER077Property, value);
                OnER077Chg();
            }
        }
        private static void OnER077Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER077 = (string)e.NewValue;
            }
        }
        public virtual void OnER077Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER077=ER077;
        }
         #endregion
       #region ==ER078===========
        public static readonly DependencyProperty ER078Property = DependencyProperty.Register("ER078",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER078Changed));
        public string ER078
        {
            get
            {
                return (string)GetValue(ER078Property);
            }
            set
            {
                SetValue(ER078Property, value);
                OnER078Chg();
            }
        }
        private static void OnER078Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER078 = (string)e.NewValue;
            }
        }
        public virtual void OnER078Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER078=ER078;
        }
         #endregion
       #region ==ER079===========
        public static readonly DependencyProperty ER079Property = DependencyProperty.Register("ER079",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER079Changed));
        public string ER079
        {
            get
            {
                return (string)GetValue(ER079Property);
            }
            set
            {
                SetValue(ER079Property, value);
                OnER079Chg();
            }
        }
        private static void OnER079Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER079 = (string)e.NewValue;
            }
        }
        public virtual void OnER079Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER079=ER079;
        }
         #endregion
       #region ==ER080===========
        public static readonly DependencyProperty ER080Property = DependencyProperty.Register("ER080",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER080Changed));
        public string ER080
        {
            get
            {
                return (string)GetValue(ER080Property);
            }
            set
            {
                SetValue(ER080Property, value);
                OnER080Chg();
            }
        }
        private static void OnER080Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER080 = (string)e.NewValue;
            }
        }
        public virtual void OnER080Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER080=ER080;
        }
         #endregion
       #region ==ER081===========
        public static readonly DependencyProperty ER081Property = DependencyProperty.Register("ER081",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER081Changed));
        public string ER081
        {
            get
            {
                return (string)GetValue(ER081Property);
            }
            set
            {
                SetValue(ER081Property, value);
                OnER081Chg();
            }
        }
        private static void OnER081Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER081 = (string)e.NewValue;
            }
        }
        public virtual void OnER081Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER081=ER081;
        }
         #endregion
       #region ==ER082===========
        public static readonly DependencyProperty ER082Property = DependencyProperty.Register("ER082",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER082Changed));
        public string ER082
        {
            get
            {
                return (string)GetValue(ER082Property);
            }
            set
            {
                SetValue(ER082Property, value);
                OnER082Chg();
            }
        }
        private static void OnER082Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER082 = (string)e.NewValue;
            }
        }
        public virtual void OnER082Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER082=ER082;
        }
         #endregion
       #region ==ER083===========
        public static readonly DependencyProperty ER083Property = DependencyProperty.Register("ER083",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER083Changed));
        public string ER083
        {
            get
            {
                return (string)GetValue(ER083Property);
            }
            set
            {
                SetValue(ER083Property, value);
                OnER083Chg();
            }
        }
        private static void OnER083Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER083 = (string)e.NewValue;
            }
        }
        public virtual void OnER083Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER083=ER083;
        }
         #endregion
       #region ==ER084===========
        public static readonly DependencyProperty ER084Property = DependencyProperty.Register("ER084",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER084Changed));
        public string ER084
        {
            get
            {
                return (string)GetValue(ER084Property);
            }
            set
            {
                SetValue(ER084Property, value);
                OnER084Chg();
            }
        }
        private static void OnER084Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER084 = (string)e.NewValue;
            }
        }
        public virtual void OnER084Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER084=ER084;
        }
         #endregion
       #region ==ER085===========
        public static readonly DependencyProperty ER085Property = DependencyProperty.Register("ER085",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER085Changed));
        public string ER085
        {
            get
            {
                return (string)GetValue(ER085Property);
            }
            set
            {
                SetValue(ER085Property, value);
                OnER085Chg();
            }
        }
        private static void OnER085Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER085 = (string)e.NewValue;
            }
        }
        public virtual void OnER085Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER085=ER085;
        }
         #endregion
       #region ==ER086===========
        public static readonly DependencyProperty ER086Property = DependencyProperty.Register("ER086",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER086Changed));
        public string ER086
        {
            get
            {
                return (string)GetValue(ER086Property);
            }
            set
            {
                SetValue(ER086Property, value);
                OnER086Chg();
            }
        }
        private static void OnER086Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER086 = (string)e.NewValue;
            }
        }
        public virtual void OnER086Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER086=ER086;
        }
         #endregion
       #region ==ER087===========
        public static readonly DependencyProperty ER087Property = DependencyProperty.Register("ER087",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER087Changed));
        public string ER087
        {
            get
            {
                return (string)GetValue(ER087Property);
            }
            set
            {
                SetValue(ER087Property, value);
                OnER087Chg();
            }
        }
        private static void OnER087Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER087 = (string)e.NewValue;
            }
        }
        public virtual void OnER087Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER087=ER087;
        }
         #endregion
       #region ==ER088===========
        public static readonly DependencyProperty ER088Property = DependencyProperty.Register("ER088",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER088Changed));
        public string ER088
        {
            get
            {
                return (string)GetValue(ER088Property);
            }
            set
            {
                SetValue(ER088Property, value);
                OnER088Chg();
            }
        }
        private static void OnER088Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER088 = (string)e.NewValue;
            }
        }
        public virtual void OnER088Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER088=ER088;
        }
         #endregion
       #region ==ER089===========
        public static readonly DependencyProperty ER089Property = DependencyProperty.Register("ER089",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER089Changed));
        public string ER089
        {
            get
            {
                return (string)GetValue(ER089Property);
            }
            set
            {
                SetValue(ER089Property, value);
                OnER089Chg();
            }
        }
        private static void OnER089Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER089 = (string)e.NewValue;
            }
        }
        public virtual void OnER089Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER089=ER089;
        }
         #endregion
       #region ==ER090===========
        public static readonly DependencyProperty ER090Property = DependencyProperty.Register("ER090",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER090Changed));
        public string ER090
        {
            get
            {
                return (string)GetValue(ER090Property);
            }
            set
            {
                SetValue(ER090Property, value);
                OnER090Chg();
            }
        }
        private static void OnER090Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER090 = (string)e.NewValue;
            }
        }
        public virtual void OnER090Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER090=ER090;
        }
         #endregion
       #region ==ER091===========
        public static readonly DependencyProperty ER091Property = DependencyProperty.Register("ER091",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER091Changed));
        public string ER091
        {
            get
            {
                return (string)GetValue(ER091Property);
            }
            set
            {
                SetValue(ER091Property, value);
                OnER091Chg();
            }
        }
        private static void OnER091Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER091 = (string)e.NewValue;
            }
        }
        public virtual void OnER091Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER091=ER091;
        }
         #endregion
       #region ==ER092===========
        public static readonly DependencyProperty ER092Property = DependencyProperty.Register("ER092",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER092Changed));
        public string ER092
        {
            get
            {
                return (string)GetValue(ER092Property);
            }
            set
            {
                SetValue(ER092Property, value);
                OnER092Chg();
            }
        }
        private static void OnER092Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER092 = (string)e.NewValue;
            }
        }
        public virtual void OnER092Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER092=ER092;
        }
         #endregion
       #region ==ER093===========
        public static readonly DependencyProperty ER093Property = DependencyProperty.Register("ER093",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER093Changed));
        public string ER093
        {
            get
            {
                return (string)GetValue(ER093Property);
            }
            set
            {
                SetValue(ER093Property, value);
                OnER093Chg();
            }
        }
        private static void OnER093Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER093 = (string)e.NewValue;
            }
        }
        public virtual void OnER093Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER093=ER093;
        }
         #endregion
       #region ==ER094===========
        public static readonly DependencyProperty ER094Property = DependencyProperty.Register("ER094",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER094Changed));
        public string ER094
        {
            get
            {
                return (string)GetValue(ER094Property);
            }
            set
            {
                SetValue(ER094Property, value);
                OnER094Chg();
            }
        }
        private static void OnER094Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER094 = (string)e.NewValue;
            }
        }
        public virtual void OnER094Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER094=ER094;
        }
         #endregion
       #region ==ER095===========
        public static readonly DependencyProperty ER095Property = DependencyProperty.Register("ER095",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER095Changed));
        public string ER095
        {
            get
            {
                return (string)GetValue(ER095Property);
            }
            set
            {
                SetValue(ER095Property, value);
                OnER095Chg();
            }
        }
        private static void OnER095Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER095 = (string)e.NewValue;
            }
        }
        public virtual void OnER095Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER095=ER095;
        }
         #endregion
       #region ==ER096===========
        public static readonly DependencyProperty ER096Property = DependencyProperty.Register("ER096",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER096Changed));
        public string ER096
        {
            get
            {
                return (string)GetValue(ER096Property);
            }
            set
            {
                SetValue(ER096Property, value);
                OnER096Chg();
            }
        }
        private static void OnER096Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER096 = (string)e.NewValue;
            }
        }
        public virtual void OnER096Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER096=ER096;
        }
         #endregion
       #region ==ER097===========
        public static readonly DependencyProperty ER097Property = DependencyProperty.Register("ER097",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER097Changed));
        public string ER097
        {
            get
            {
                return (string)GetValue(ER097Property);
            }
            set
            {
                SetValue(ER097Property, value);
                OnER097Chg();
            }
        }
        private static void OnER097Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER097 = (string)e.NewValue;
            }
        }
        public virtual void OnER097Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER097=ER097;
        }
         #endregion
       #region ==ER098===========
        public static readonly DependencyProperty ER098Property = DependencyProperty.Register("ER098",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER098Changed));
        public string ER098
        {
            get
            {
                return (string)GetValue(ER098Property);
            }
            set
            {
                SetValue(ER098Property, value);
                OnER098Chg();
            }
        }
        private static void OnER098Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER098 = (string)e.NewValue;
            }
        }
        public virtual void OnER098Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER098=ER098;
        }
         #endregion
       #region ==ER099===========
        public static readonly DependencyProperty ER099Property = DependencyProperty.Register("ER099",
            typeof(string), typeof(UIICC_WBERROR),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnER099Changed));
        public string ER099
        {
            get
            {
                return (string)GetValue(ER099Property);
            }
            set
            {
                SetValue(ER099Property, value);
                OnER099Chg();
            }
        }
        private static void OnER099Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var src = sender as UIICC_WBERROR;
            if (src != null)
            {
                src.ER099 = (string)e.NewValue;
            }
        }
        public virtual void OnER099Chg()
        { 
        if(!IsEdit)
        return;
        if(dwMaster==null)
        return;
        TMV.ER099=ER099;
        }
         #endregion
       */
       
       #endregion
    } 
}
